home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / gnu / ms-0_06.lha / xms-0.06 / Ms.c < prev    next >
C/C++ Source or Header  |  1991-11-10  |  27KB  |  897 lines
  1. /* Ms.c - MandelSpawn popup widget */
  2.  
  3. /*  This file is part of MandelSpawn, a parallel Mandelbrot program for
  4.     the X window system.
  5.  
  6.     Copyright (C) 1990, 1991 Andreas Gustafsson
  7.  
  8.     MandelSpawn is free software; you can redistribute it and/or modify
  9.     it under the terms of the GNU General Public License, version 1,
  10.     as published by the Free Software Foundation.
  11.  
  12.     MandelSpawn is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License,
  18.     version 1, along with this program; if not, write to the Free 
  19.     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. /* This widget creates a window showing a part of the Mandelbrot set */
  23.  
  24. #include <stdio.h>
  25. #include <math.h>
  26.  
  27. #include <X11/IntrinsicP.h>
  28. #include <X11/Xos.h>
  29. #include <X11/StringDefs.h>
  30.  
  31. /* We need ntohs() and htonl(); on some systems (HP-UX comes to mind) */
  32. /* they are macros defined in <netinet/in.h> and nowhere else, with */
  33. /* no corresponding library function. */
  34. #include <netinet/in.h>    
  35.  
  36. #include "backward.h" /* X11R2 backward compatibility stuff */
  37.  
  38. #include "MsP.h" /* includes Ms.h which includes MsJob.h */
  39. #include "Mama.h"
  40.  
  41. extern XtAppContext thisApp;
  42. extern Display *myDisplay;
  43. extern Screen *myScreen;
  44.  
  45. /* Misc. functions */
  46. static void
  47.     ClassInitialize(), Initialize(), Resize(), Realize(), Destroy(), 
  48.     InvertBox(), EraseBox(), HideBox(), UnhideBox(),
  49.     DoExpose();
  50.  
  51. /* These are used by menu choises in R4menu.c */
  52. void ZoomIn(), WindowStats();
  53.  
  54. /* Action functions */
  55. static void
  56.     BeginBoxAction(), StretchBoxAction(), EndBoxAction(),
  57.     ZoomAction(), CloseAction(), QuitAction(), ApplStatsAction(), 
  58.     WindowStatsAction();
  59.  
  60. #ifdef MENU
  61. void MsCreateMenu();
  62. #endif
  63. #ifdef LABEL
  64. void MsCreateUnderflowLabel();
  65. #endif
  66.  
  67. static Boolean SetValues();
  68.  
  69.  
  70. /* supported visual type / iteration count length combinations */
  71. /* are obtained by ORing togeter one ITER_x and one DISP_x value */
  72.  
  73. #define ITER_BYTE        0
  74. #define ITER_WORD        1
  75.  
  76. #define DISP_unknown        0
  77. #define DISP_1plane32msb     2  /* like a Sun monochrome display */
  78. #define DISP_1plane32lsb     4  /* like a DECstation monochrome display */
  79. #define DISP_8plane        6  /* typical 8-plane framebuffer */
  80. #define DISP_generic        8  /* none of the above */
  81.  
  82.  
  83. /* Defaults */
  84.  
  85. static Dimension default_width = 400;    /* window width in pixels */
  86. static Dimension default_height = 250;    /* window height in pixels */
  87. static int default_iteration_limit = 0;    /* 0 means undefined */
  88. static double default_center_x = (-0.5); /* x coordinate of window center */
  89. static double default_center_y = 0.0;    /* y coordinate of window center */
  90. static double default_range = 4.0;     /* window range in x direction */
  91. static Bool default_center_box = True;    /* do we center the rubberband box? */
  92. static Bool default_julia = False;    /* do we show the Julia set? */
  93. static double default_c_x = 0.0;     /* c parameter for Julia, real */
  94. static double default_c_y = 0.0;    /* c parameter for Julia, im */
  95. static double default_julia_range = 4.0; /* window range for Julia */
  96. static double default_julia_center_x = 0.0; /* window center x for Julia */
  97. static double default_julia_center_y = 0.0; /* window center y for Julia */
  98. static char default_cursor[] = "top_left_arrow"; 
  99. static unsigned default_chunk_width = 32;
  100. static unsigned default_chunk_height = 32;
  101. static Bool default_sony_bug_workaround = False;
  102. static Bool default_crosshair_size = 3;
  103. static Bool default_show_interior = False;
  104.  
  105.  
  106. extern char msDefaultTranslations[];
  107.  
  108. #ifndef MENU
  109. /* Some of these bindings are less than obvious.  Don't complain, */
  110. /* get X11R4 and Xaw so you can use the popup menu in R4menu.c. */
  111. char msDefaultTranslations[] = 
  112.     "<Btn1Down>:    BeginBox()        \n\
  113.      <Btn1Motion>:    StretchBox()        \n\
  114.      <Btn1Up>:        EndBox()        \n\
  115.      Shift<Btn2Down>:    Zoom(nopop,nojulia,in)    \n\
  116.      <Btn2Down>:    Zoom(popup,nojulia,in)    \n\
  117.      Shift<Btn3Down>:    Quit()            \n\
  118.      <Btn3Down>:    Close()            \n\
  119.      Shift<Key>z:    Zoom(nopop,nojulia,in)    \n\
  120.      <Key>z:        Zoom(popup,nojulia,in)    \n\
  121.      Shift<Key>o:    Zoom(nopop,nojulia,out)    \n\
  122.      <Key>o:        Zoom(popup,nojulia,out)    \n\
  123.      Shift<Key>j:    Zoom(nopop,julia,in)    \n\
  124.      <Key>j:        Zoom(popup,julia,in)    \n\
  125.      <Key>s:        ApplStats()        \n\
  126.      <Key>w:        WindowStats()        \n\
  127.      <Key>c:        Close()            \n\
  128.      <Key>q:        Quit()            \n\
  129.   ";
  130. #endif
  131.  
  132. static XtActionsRec actionsList[] =
  133. {
  134.     { "BeginBox",    BeginBoxAction        },
  135.     { "EndBox",        EndBoxAction        },
  136.     { "StretchBox",    StretchBoxAction    },
  137.     { "Zoom",        ZoomAction        },
  138.     { "WindowStats",    WindowStatsAction    },
  139.     { "ApplStats",    ApplStatsAction        },
  140.     { "Close",        CloseAction        },
  141.     { "Quit",        QuitAction        }
  142. };
  143.  
  144. static XtResource resources[] = 
  145. {   /* Core resources */
  146.     { XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
  147.     XtOffset(Widget, core.width), XtRDimension,
  148.     (caddr_t) &default_width },
  149.     { XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
  150.     XtOffset(Widget, core.height), XtRDimension,
  151.     (caddr_t) &default_height },
  152.     /* Noncore resources */
  153.     { XtNiteration_limit, XtCValue, XtRInt, sizeof(int),
  154.     XtOffset(MsWidget, ms.xi.job.iteration_limit), XtRInt,
  155.     (caddr_t) &default_iteration_limit },
  156.     { XtNCenterX, XtCValue, XtRDouble, sizeof(double),
  157.     XtOffset(MsWidget, ms.xi.center_x), XtRDouble,
  158.     (caddr_t) &default_center_x },
  159.     { XtNCenterY, XtCValue, XtRDouble, sizeof(double),
  160.     XtOffset(MsWidget, ms.xi.center_y), XtRDouble,
  161.     (caddr_t) &default_center_y },
  162.     { XtNRange, XtCValue, XtRDouble, sizeof(double),
  163.     XtOffset(MsWidget, ms.xi.xrange), XtRDouble,
  164.     (caddr_t) &default_range },
  165.     { XtNCenterBox, XtCValue, XtRBool, sizeof(Bool),
  166.     XtOffset(MsWidget, ms.center_box), XtRBool,
  167.     (caddr_t) &default_center_box },
  168.     { XtNCursor, XtCValue, XtRCursor, sizeof(Cursor),
  169.     XtOffset(MsWidget, ms.my_cursor), XtRString,
  170.     (caddr_t) default_cursor },
  171.     { XtNMama, XtCValue, XtRPointer, sizeof(MamaWidget),
  172.     XtOffset(MsWidget, ms.mama), XtRPointer,
  173.     (caddr_t) 0 } ,
  174.     { XtNJulia, XtCValue, XtRBool, sizeof(Bool),
  175.     XtOffset(MsWidget, ms.xi.julia), XtRBool,
  176.     (caddr_t) &default_julia },
  177.     { XtNCX, XtCValue, XtRDouble, sizeof(double),
  178.     XtOffset(MsWidget, ms.xi.c_x), XtRDouble,
  179.     (caddr_t) &default_c_x },
  180.     { XtNCY, XtCValue, XtRDouble, sizeof(double),
  181.     XtOffset(MsWidget, ms.xi.c_y), XtRDouble,
  182.     (caddr_t) &default_c_y },
  183.     { XtNChunkWidth, XtCValue, XtRInt, sizeof(unsigned int),
  184.     XtOffset(MsWidget, ms.xi.chunk_width), XtRInt,
  185.     (caddr_t) &default_chunk_width },
  186.     { XtNChunkHeight, XtCValue, XtRInt, sizeof(unsigned int),
  187.     XtOffset(MsWidget, ms.xi.chunk_height), XtRInt,
  188.     (caddr_t) &default_chunk_height },
  189.     { XtNSony, XtCValue, XtRBool, sizeof(Bool),
  190.         XtOffset(MsWidget, ms.sony_bug_workaround), XtRBool,
  191.         (caddr_t) &default_sony_bug_workaround },
  192.     { XtNCrosshairSize, XtCValue, XtRInt, sizeof(int),
  193.         XtOffset(MsWidget, ms.crosshair_size), XtRInt,
  194.         (caddr_t) &default_crosshair_size },
  195.     { XtNInterior, XtCValue, XtRBool, sizeof(Bool),
  196.         XtOffset(MsWidget, ms.xi.show_interior), XtRBool,
  197.         (caddr_t) &default_show_interior }
  198.  
  199. };
  200.  
  201. MsClassRec msClassRec = 
  202. {   /* core fields */
  203.     { 
  204.     /* superclass        */    (WidgetClass) &compositeClassRec,
  205.     /* class_name        */    "MandelSpawn",
  206.     /* widget_size        */    sizeof(MsRec),
  207.     /* class_initialize        */      NULL,
  208.     /* class_part_initialize    */    NULL,
  209.     /* class_inited        */    FALSE,
  210.     /* initialize        */    Initialize,
  211.     /* initialize_hook        */    NULL,
  212.     /* realize            */    Realize,
  213.     /* actions            */    actionsList,
  214.     /* num_actions        */    XtNumber(actionsList),
  215.     /* resources        */    resources,
  216.     /* resource_count        */    XtNumber(resources),
  217.     /* xrm_class        */    NULL,
  218.     /* compress_motion        */    TRUE,
  219.     /* compress_exposure    */    FALSE,
  220.     /* compress_enterleave    */    TRUE,
  221.     /* visible_interest        */    FALSE,
  222.     /* destroy            */    Destroy,
  223.     /* resize            */    Resize,
  224.     /* expose            */    DoExpose,
  225.     /* set_values        */    SetValues,
  226.     /* set_values_hook        */    NULL,
  227.     /* set_values_almost    */    XtInheritSetValuesAlmost,
  228.     /* get_values_hook        */    NULL,
  229.     /* accept_focus        */    NULL,
  230.     /* version            */    XtVersion,
  231.     /* callback_private        */    NULL,
  232.     /* tm_table            */    msDefaultTranslations,
  233.     /* query_geometry        */    NULL
  234.     },
  235.     /* CompositeClassPart fields */
  236.     { XtInheritGeometryManager,
  237.       XtInheritChangeManaged,
  238.       XtInheritInsertChild,
  239.       XtInheritDeleteChild
  240.     },
  241.     /* msClassPart fields */
  242.     {
  243.     /* dummy            */    0
  244.     }
  245. };
  246.  
  247. WidgetClass msWidgetClass = (WidgetClass) &msClassRec;
  248.  
  249.  
  250. /* Initialize the widget */
  251.  
  252. static void
  253. Initialize(request, new)
  254.      MsWidget   request;
  255.      MsWidget   new;
  256. { XGCValues gcv;
  257.   int depth = DefaultDepthOfScreen(XtScreen(new));
  258.   /* set up a GC for the rubberband box */
  259.   gcv.function=GXxor;
  260.   
  261.   /* "gcv.foreground=~0l" messes up the black-and-white mode of the */
  262.   /* X11R2 server for the Sony NWS-1510 4-plane display quite badly; */
  263.   /* I'd call that a server bug.  The code below works but assumes */
  264.   /* 2's complement. */
  265.   if(depth==32)
  266.     gcv.foreground=0xffffffff; /* 1<<32 is undefined, says K&R */
  267.   else
  268.     gcv.foreground= (1 << depth) - 1;
  269.   new->ms.box_gc=XtGetGC(new, GCFunction|GCForeground, &gcv);
  270.   new->ms.box_exists=False;
  271.   new->ms.box_hidden=0;
  272.   new->ms.rectbuffer=(XImage *) NULL; /* no rectangle buffer so far */
  273. #ifdef LABEL
  274.   new->ms.underflow=0;
  275.   new->ms.underflow_label=NULL;
  276. #endif
  277.   ms_init(&new->ms.xi, MamaWorkforce(new->ms.mama));
  278. }
  279.  
  280.  
  281. /* Initialize, or re-initialize widget fields that may need to be */
  282. /* changed when the widget is resized, zoomed or otherwise modified */
  283.  
  284. static void MsPrecalculate(w) MsWidget w;
  285. { int underflow;
  286.   w->ms.xi.height = w->core.height;
  287.   w->ms.xi.width = w->core.width;
  288.   
  289.   ms_calculate_job_parameters(&w->ms.xi, &w->ms.xi.job);
  290.  
  291. #ifdef LABEL
  292.   underflow=(w->ms.xi.job.delta.re == 0 || w->ms.xi.job.delta.im == 0);
  293.  
  294.   if(underflow && !w->ms.underflow)
  295.   { MsCreateUnderflowLabel(w);
  296.   }
  297.   if(!underflow && w->ms.underflow)
  298.   { XtDestroyWidget(w->ms.underflow_label);
  299.   }
  300.   w->ms.underflow = underflow;
  301. #endif
  302.  
  303.   /* if it had a rectangle buffer already, destroy it */
  304.   if(w->ms.rectbuffer)
  305.     XDestroyImage(w->ms.rectbuffer);
  306.  
  307.   /* create the rectangle buffer */
  308.   w->ms.rectbuffer=
  309.     XCreateImage(XtDisplay(w), DefaultVisualOfScreen(XtScreen(w)), 
  310.          DefaultDepthOfScreen(XtScreen(w)), ZPixmap, 0, (char *) NULL, 
  311.          w->ms.xi.chunk_width, w->ms.xi.chunk_height, 32,
  312.          0 /* zero means let XCreateImage determine bytes/line */
  313.         );
  314.   w->ms.rectbuffer_size=(unsigned) w->ms.rectbuffer->bytes_per_line * 
  315.     w->ms.xi.chunk_height;
  316.   w->ms.rectbuffer->data=(char *) XtMalloc(w->ms.rectbuffer_size);
  317.  
  318.   if(w->ms.xi.job.iteration_limit == 0) /* not set yet? */
  319.   { /* iterate as far as possible by default */
  320.     w->ms.xi.job.iteration_limit = MaxIterations(w->ms.mama);
  321.   }
  322.   else
  323.     if(w->ms.xi.job.iteration_limit > MaxIterations(w->ms.mama))
  324.     { w->ms.xi.job.iteration_limit=MaxIterations(w->ms.mama);
  325.       XtAppWarning(thisApp,
  326.            "Iteration limit truncated");
  327.     }
  328.  
  329.   w->ms.xi.bytes_per_count=(w->ms.xi.job.iteration_limit > 256 ? 2 : 1);
  330.  
  331.   /* determine the kind of draw routine to use depending on */
  332.   /* display characteristics and iteration count size */
  333.  
  334.   if(w->ms.rectbuffer->bits_per_pixel == 8)
  335.     w->ms.type=DISP_8plane;
  336.   else if(w->ms.rectbuffer->bits_per_pixel == 1  &&
  337.         w->ms.rectbuffer->bitmap_unit==32 &&
  338.         w->ms.rectbuffer->bitmap_bit_order != LSBFirst)
  339.       w->ms.type=DISP_1plane32msb;
  340.   else if(w->ms.rectbuffer->bits_per_pixel == 1  &&
  341.             w->ms.rectbuffer->bitmap_unit==32 &&
  342.             w->ms.rectbuffer->bitmap_bit_order == LSBFirst)
  343.       w->ms.type=DISP_1plane32lsb;
  344.   else
  345.   { w->ms.type=DISP_generic;
  346.     XtAppWarning(thisApp,
  347.          "No special case support for this display type;\n\
  348. drawing a pixel at a time, this will be very slow.");
  349.   }
  350.  
  351.   w->ms.type |= (w->ms.xi.bytes_per_count==2) ? ITER_WORD : ITER_BYTE;
  352.  
  353.   /* We now have a new configuration; give it a unique number */
  354.   w->ms.xi.configuration++;
  355. }
  356.  
  357.  
  358. /* Calculate the coordinates for the rubberband box given the initial */
  359. /* and current mouse position (box_origin, box_corner). Use the box_origin */
  360. /* as either the center or the oppsite corner depending on the center_box */
  361. /* flag */
  362.  
  363. struct box UnflipBox(w)
  364.      MsWidget w;
  365. { struct box r;
  366.   if(w->ms.center_box)
  367.   { int halfwidth=ABS(w->ms.box_corner.x - w->ms.box_origin.x);
  368.     int halfheight=ABS(w->ms.box_corner.y - w->ms.box_origin.y);
  369.     r.x0=w->ms.box_origin.x-halfwidth;
  370.     r.x1=w->ms.box_origin.x+halfwidth;
  371.     r.y0=w->ms.box_origin.y-halfheight;
  372.     r.y1=w->ms.box_origin.y+halfheight;
  373.   }
  374.   else
  375.   { r.x0=MIN(w->ms.box_origin.x, w->ms.box_corner.x);
  376.     r.x1=MAX(w->ms.box_origin.x, w->ms.box_corner.x);
  377.     r.y0=MIN(w->ms.box_origin.y, w->ms.box_corner.y);
  378.     r.y1=MAX(w->ms.box_origin.y, w->ms.box_corner.y);
  379.   }
  380.   return(r);
  381. }
  382.  
  383.  
  384. /* Zoom into the area selected using the box.  If "pop", pop up a new */
  385. /* window.  If "julia", show the Julia set corresponding to the point */
  386. /* at the center of the box.  If "outwards", zoom out instead of in. */
  387.  
  388. void ZoomIn(w, pop, julia, outwards)
  389.        MsWidget w;
  390.        int pop;
  391.        int julia;
  392.        int outwards;
  393. { struct box b;
  394.   double scale;
  395.   double new_xrange, new_center_x, new_center_y;
  396.   Arg arglist[16];
  397.   int num_args;
  398.   Arg shell_arglist[16];
  399.   int num_shell_args;
  400.   int boxwidth;
  401.   double nx, ny;
  402.  
  403.   if(!w->ms.box_exists)
  404.     return;
  405.  
  406.   b=UnflipBox(w);  
  407.  
  408.   boxwidth = b.x1-b.x0;
  409.  
  410.   /* caculate location of box center normalized so that 0 = window center, */
  411.   /* +-0.5 = window edge */
  412.   nx = ((((double) b.x0+b.x1)/2)-(w->core.width/2)) / (double)(w->core.width);
  413.   ny = ((((double) b.y0+b.y1)/2)-(w->core.height/2)) /    (double)(w->core.height);
  414.       
  415.   if(outwards) /* zoom out */
  416.   { if(boxwidth==0)
  417.     { /* avoid division by zero */
  418.       new_xrange = default_range;
  419.       new_center_x = w->ms.xi.center_x;
  420.       new_center_y = w->ms.xi.center_y;
  421.     }
  422.     else
  423.     { scale = (double) w->core.width / (double) boxwidth;
  424.       new_xrange = w->ms.xi.xrange * scale;
  425.       new_center_x = w->ms.xi.center_x - nx * scale * w->ms.xi.xrange;
  426.       new_center_y = w->ms.xi.center_y - ny * scale * w->ms.xi.yrange;
  427.     }
  428.   }
  429.   else /* zoom in */
  430.   { scale = (double) boxwidth / (double) (w->core.width);
  431.     new_xrange = w->ms.xi.xrange * scale;
  432.     new_center_x = w->ms.xi.center_x + nx * w->ms.xi.xrange;
  433.     new_center_y = w->ms.xi.center_y + ny * w->ms.xi.yrange;
  434.   }
  435.   
  436.   /* build arguments for the changed resources in the zoomed widget */
  437.   num_args=0;
  438.  
  439.   /* Transition from Mandelbrot to Julia set */
  440.   if(julia && !(w->ms.xi.julia))
  441.   { XtSetArg(arglist[num_args], XtNJulia, True); num_args++;
  442.     /* Set the C parameter (chooses a Julia set out of infinitely many) */
  443.     XtSetArg(arglist[num_args], XtNCX, &new_center_x); num_args++;
  444.     XtSetArg(arglist[num_args], XtNCY, &new_center_y); num_args++;
  445.     /* This is an initial Julia picture, so show the whole Julia set */
  446.     XtSetArg(arglist[num_args], XtNRange, &default_julia_range); num_args++;
  447.     XtSetArg(arglist[num_args], XtNCenterX,
  448.          &default_julia_center_x); num_args++;
  449.     XtSetArg(arglist[num_args], XtNCenterY,
  450.          &default_julia_center_y); num_args++;
  451.   }
  452.   else /* No change in M/J mode */
  453.   { XtSetArg(arglist[num_args], XtNJulia, w->ms.xi.julia); num_args++;
  454.     XtSetArg(arglist[num_args], XtNCenterX, &new_center_x); num_args++;
  455.     XtSetArg(arglist[num_args], XtNCenterY, &new_center_y); num_args++;
  456.     XtSetArg(arglist[num_args], XtNRange, &new_xrange); num_args++;
  457.     /* these two parameters are redundant in the Mandelbrot mode */
  458.     XtSetArg(arglist[num_args], XtNCX, &w->ms.xi.c_x); num_args++;
  459.     XtSetArg(arglist[num_args], XtNCY, &w->ms.xi.c_y); num_args++;
  460.   }
  461.  
  462.   XtSetArg(arglist[num_args], XtNMama, w->ms.mama); num_args++;
  463.  
  464.   if(pop)
  465.   { num_shell_args = 0;
  466.     /* make the new window as big as this one initially */
  467.     XtSetArg(shell_arglist[num_shell_args], XtNheight, w->core.height);
  468.     num_shell_args++;
  469.     XtSetArg(shell_arglist[num_shell_args], XtNwidth, w->core.width);
  470.     num_shell_args++;
  471.     /* create a new pop-up window for the zoomed area */
  472.     PopupAnother(w->ms.mama, shell_arglist, num_shell_args, arglist, num_args);
  473.   }
  474.   else 
  475.   {
  476. #if 1
  477.     /* zoom using the old window: just set the changed resources */
  478.     EraseBox(w);
  479.     XtSetValues(w, arglist, num_args);
  480. #else
  481.     /* Code under construction.  Hazardous area, do not enter. */
  482.     /* unmap the shell widget */
  483.     XtUnmapWidget(XtParent(w));
  484.     /* should make new window use same location as the old one, */
  485.     /* without WM intervention.  How? */
  486.     num_shell_args = 0;
  487.     /* make the new window as big as this one initially */
  488.     XtSetArg(shell_arglist[num_shell_args], XtNheight, w->core.height);
  489.     num_shell_args++;
  490.     XtSetArg(shell_arglist[num_shell_args], XtNwidth, w->core.width);
  491.     num_shell_args++;
  492.     /* create a new pop-up window for the zoomed area */
  493.     PopupAnother(w->ms.mama, shell_arglist, num_shell_args, arglist, num_args);
  494. #endif
  495.   }
  496. }
  497.  
  498.  
  499. /* Action routine interface to ZoomIn */
  500.  
  501. static void ZoomAction(w, event, params, nparams)
  502.      MsWidget w;
  503.      XEvent *event;
  504.      String *params;
  505.      Cardinal *nparams;
  506. { 
  507.   if(*nparams != 3)
  508.   { XtAppWarning(thisApp, "ZoomAction: wrong number of arguments");
  509.     return;
  510.   }
  511.   ZoomIn(w, params[0][0] == 'p', params[1][0] == 'j', params[2][0] == 'o');
  512. }
  513.  
  514.  
  515. /* Handle widget exposure */
  516. /* Can't call this "Expose" because that is #defined to 12 in X.h! */
  517.  
  518. /*ARGSUSED*/
  519. static void DoExpose (w, e, r)
  520.      MsWidget    w;
  521.      XEvent *e;
  522.      Region r;
  523. {
  524. #ifdef LABEL
  525.   /* It's no use redrawing if underflow has occured */
  526.   if(w->ms.underflow)
  527.     return;
  528. #endif
  529.  
  530.   /* remove the box for the duration of the update */
  531.   if(w->ms.xi.chunks_out==0)
  532.     HideBox(w);
  533.   
  534.   ms_dispatch_rect(&w->ms.xi, (char *) w,
  535.            e->xexpose.x, e->xexpose.y,
  536.            e->xexpose.width, e->xexpose.height
  537.           );
  538. }
  539.  
  540.  
  541. /* Draw (or undraw) the rubberband box */
  542.  
  543. static void InvertBox(w)
  544.      MsWidget w;
  545. { struct box b;
  546.   /* draw only if no update is in progress */
  547.   if(!w->ms.box_hidden)
  548.   { int armx, army;
  549.     armx=army=w->ms.crosshair_size;
  550.     b=UnflipBox(w);
  551.     XDrawRectangle(XtDisplay(w), XtWindow(w), w->ms.box_gc,
  552.            b.x0, b.y0, b.x1-b.x0, b.y1-b.y0);
  553.     if(armx || army)
  554.     { /* draw a crosshair at the center of the selected area */
  555.       int xc = (b.x0+b.x1)/2;
  556.       int yc = (b.y0+b.y1)/2;
  557.       XDrawLine(XtDisplay(w), XtWindow(w), w->ms.box_gc,
  558.         xc-armx, yc, xc+armx, yc);
  559.       XDrawLine(XtDisplay(w), XtWindow(w), w->ms.box_gc,
  560.         xc, yc-army, xc, yc+army);
  561.     }
  562.     w->ms.box_exists = !(w->ms.box_exists);
  563.   }
  564. }
  565.  
  566.  
  567. /* Erase the rubberband box if it exists */
  568.  
  569. static void EraseBox(w)
  570.      MsWidget w;
  571. { if(w->ms.box_exists) InvertBox(w);
  572. }
  573.  
  574.  
  575.  
  576. /* Create the rubberband box */
  577.  
  578. static void BeginBoxAction(w, event, params, nparams)
  579.      MsWidget w;
  580.      XEvent *event;
  581.      String *params;
  582.      Cardinal *nparams;
  583. { EraseBox(w);
  584.   w->ms.box_origin.x=w->ms.box_corner.x=((XButtonEvent *) event)->x;
  585.   w->ms.box_origin.y=w->ms.box_corner.y=((XButtonEvent *) event)->y;
  586.   InvertBox(w);
  587. }
  588.  
  589.  
  590. /* Stretch the rubberband box */
  591.  
  592. static void StretchBoxAction(w, event, params, nparams)
  593.      MsWidget w;
  594.      XEvent *event;
  595.      String *params;
  596.      Cardinal *nparams;
  597. { EraseBox(w);
  598.   w->ms.box_corner.x=((XButtonEvent *) event)->x;
  599.   w->ms.box_corner.y=((XButtonEvent *) event)->y;
  600.   InvertBox(w);
  601. }
  602.  
  603.  
  604. /* Stop stretching the rubberband box (currently a no-op) */
  605.  
  606. static void EndBoxAction(w, event, params, nparams)
  607.      MsWidget w;
  608.      XEvent *event;
  609.      String *params;
  610.      Cardinal *nparams;
  611. {
  612. }
  613.  
  614.  
  615. /* Hide the box when beginning an asynchronous update */
  616.  
  617. static void HideBox(w)
  618.      MsWidget w;
  619. { if(w->ms.box_hidden==0 && w->ms.box_exists)
  620.     InvertBox(w);
  621.   w->ms.box_hidden++;
  622. }
  623.  
  624.  
  625. /* Unhide the box when an asynchronous update is done */
  626.  
  627. static void UnhideBox(w)
  628.      MsWidget w;
  629. { w->ms.box_hidden--;
  630.   if(w->ms.box_hidden==0 && w->ms.box_exists) 
  631.     InvertBox(w);
  632. }
  633.  
  634.  
  635. /* Realize the widget */
  636.  
  637. static void
  638. Realize (w, valueMask, attrs)
  639.      MsWidget w;
  640.      XtValueMask *valueMask;
  641.      XSetWindowAttributes *attrs;
  642. { /* setting the colormap here is probably redundant */
  643.   attrs->backing_store=Always;
  644.   attrs->save_under=False;
  645.   attrs->bit_gravity=ForgetGravity;
  646.   attrs->cursor=w->ms.my_cursor;
  647.   attrs->colormap=MamaColormap(w->ms.mama);
  648.   XtCreateWindow (w, InputOutput, (Visual *) CopyFromParent,
  649.     *valueMask | CWBackingStore | CWSaveUnder| CWBitGravity | CWCursor |
  650.           CWColormap, attrs);
  651.   MsPrecalculate(w);
  652. #ifdef MENU
  653.   MsCreateMenu(w, !w->ms.xi.julia);
  654. #endif
  655. }
  656.  
  657.  
  658. /* Destroy the widget */
  659.  
  660. static void
  661. Destroy (w)
  662.      MsWidget w;
  663. { XtReleaseGC(w, w->ms.box_gc);
  664.   XtFree((char *) w->ms.rectbuffer);
  665. }
  666.  
  667.  
  668. /* Update widget resources */
  669.  
  670. static Boolean SetValues(current, request, new)
  671.      MsWidget current, request, new;
  672. { MsPrecalculate(new); /* do the dirty work */
  673.   return(True); /* widget must be redisplayed */
  674. }
  675.  
  676.  
  677. /* Resize the widget */
  678.  
  679. static void
  680. Resize(w)
  681.      MsWidget w;
  682. { MsPrecalculate(w); /* do the dirty work */
  683. }
  684.  
  685.  
  686. /* Print the view coordinates */
  687.  
  688. void WindowStats(w)
  689.      MsWidget w;
  690. { (void) printf("current picture area: x = %f .. %f, y = %f .. %f\n",
  691.         w->ms.xi.center_x - w->ms.xi.xrange / 2,
  692.         w->ms.xi.center_x + w->ms.xi.xrange / 2,
  693.         w->ms.xi.center_y - w->ms.xi.yrange / 2,
  694.         w->ms.xi.center_y + w->ms.xi.yrange / 2
  695.            );
  696.   (void) printf("return here with: xms ");
  697.   if(w->ms.xi.julia)
  698.     (void) printf("-julia -cx %f -cy %f ", w->ms.xi.c_x, w->ms.xi.c_y);
  699.   (void) printf("-x %f -y %f -range %f\n",
  700.            w->ms.xi.center_x, w->ms.xi.center_y, w->ms.xi.xrange);
  701. }
  702.  
  703.  
  704. /* Action routine for the above */
  705.  
  706. static void WindowStatsAction(w, event, params, nparams)
  707.      MsWidget w;
  708.      XEvent *event;
  709.      String *params;
  710.      Cardinal *nparams;
  711. { WindowStats(w);
  712. }
  713.  
  714.  
  715. /* Print slave performance statistics */
  716.  
  717. static void ApplStatsAction(w, event, params, nparams)
  718.      MsWidget w;
  719.      XEvent *event;
  720.      String *params;
  721.      Cardinal *nparams;
  722. { SlaveStatistics(w->ms.mama);
  723. }
  724.  
  725.  
  726. /* auxiliary macro for ms_draw: */
  727.  
  728. #define DRAW_SINGLEPLANE(iter_type, init_mask, shift_op) \
  729.  { iter_type *datap = (iter_type *) data; \
  730.    for(j=0; j<height; j++) \
  731.    { unsigned char *bufp = (unsigned char *) w->ms.rectbuffer->data + \
  732.        (w->ms.rectbuffer->bytes_per_line * j); \
  733.      for(i=0; i<width; ) /* for each byte */ \
  734.      { unsigned pixbyte = 0; \
  735.        unsigned mask = init_mask; \
  736.        unsigned end=MIN(width, i+8); \
  737.        for(; i<end; i++) /* for each bit in the byte */ \
  738.        { if(pixels[*datap++]) \
  739.        pixbyte |= mask; \
  740.      mask shift_op 1; \
  741.        } \
  742.        *bufp++ = pixbyte; \
  743.      } \
  744.    } \
  745.  }
  746.  
  747.  
  748. /* This function is called when a chunk has been completed by a slave */
  749. /* to draw it on the screen */
  750.  
  751. void ms_draw(client, client_data, data)
  752.      char *client;
  753.      char *client_data;
  754.      char *data; 
  755. { MsWidget w = (MsWidget) client;
  756.   register int i, j;
  757.   unsigned int x, y, width, height;
  758.  
  759.   ms_client_info *the_info = (ms_client_info *) client_data;
  760.  
  761.   unsigned long *pixels = MamaPixels(w->ms.mama);
  762.  
  763.   /* Ignore the reply if the widget has changed shape or something */
  764.   if(the_info->configuration == w->ms.xi.configuration)
  765.   { x=the_info->s.x; 
  766.     y=the_info->s.y; 
  767.     width=the_info->s.width;
  768.     height=the_info->s.height;
  769.  
  770.     /* 16-bit iteration counts from the slave need to be */
  771.     /* converted from network byte order.  It is faster */
  772.     /* to do it all at once here than to call ntohs() */
  773.     /* in the tight loops below.  Any decent compiler will */
  774.     /* optimize away the whole "if" statement if the CPU */
  775.     /* is big-endian; if it is little-endian then a single */
  776.     /* redundant ntohs() call will remain in the "if" condition. */
  777.  
  778.     if(ntohs(1) != 1)
  779.     { if(w->ms.xi.bytes_per_count == sizeof(unsigned short))
  780.       {    unsigned short *end;
  781.     register unsigned char *p;
  782.     end = (unsigned short *) data + (width * height);
  783.     for(p = (unsigned char *) data; p < (unsigned char *) end; p += 2)
  784.     { unsigned char tmp;
  785.       tmp = *p;
  786.       *p = *(p+1);
  787.       *(p+1) = tmp;
  788.     }
  789.       }
  790.     }
  791.  
  792.     /* sorry about the combinatorial explosion, but this part easily */
  793.     /* becomes a bottleneck if all the tests are done inside the loop */
  794.     switch(w->ms.type)
  795.     {
  796.     case ITER_BYTE|DISP_1plane32msb:
  797.       DRAW_SINGLEPLANE(unsigned char, 0x80, >>=);
  798.       break;
  799.     case ITER_WORD|DISP_1plane32msb:
  800.       DRAW_SINGLEPLANE(unsigned short, 0x80, >>=);
  801.       break;
  802.     case ITER_BYTE|DISP_1plane32lsb:
  803.       DRAW_SINGLEPLANE(unsigned char, 0x01, <<=);
  804.       break;
  805.     case ITER_WORD|DISP_1plane32lsb:
  806.       DRAW_SINGLEPLANE(unsigned short, 0x01, <<=);
  807.       break;
  808.     case ITER_BYTE|DISP_8plane:
  809.       /* Quick-and-dirty drawing of 8-bit values on 8-plane displays */
  810.       { unsigned char *datap = (unsigned char *) data;
  811.     for(j=0; j<height; j++)
  812.     { unsigned char *bufp= (unsigned char *)
  813.         w->ms.rectbuffer->data + (w->ms.rectbuffer->bytes_per_line * j);
  814.       for(i=0; i<width; i++)
  815.       { *bufp++ = pixels[*datap++];
  816.       }
  817.     }
  818.       }
  819.       break;
  820.     case ITER_WORD|DISP_8plane:
  821.       /* Quick-and-dirty drawing of 16-bit values on 8-plane displays */
  822.       { unsigned short *datap = (unsigned short *) data;
  823.     for(j=0; j<height; j++)
  824.     { unsigned char *bufp= (unsigned char *)
  825.         w->ms.rectbuffer->data + (w->ms.rectbuffer->bytes_per_line * j);
  826.       for(i=0; i<width; i++)
  827.       { *bufp++ = pixels[*datap++];
  828.       }
  829.     }
  830.       }
  831.       break;
  832.     case ITER_BYTE|DISP_generic:
  833.       /* Slow but portable drawing of 8-bit values on 8-plane displays */
  834.       { unsigned char *datap = (unsigned char *) data;
  835.     for(j=0; j<height; j++)
  836.     { for(i=0; i<width; i++)
  837.         XPutPixel(w->ms.rectbuffer, i, j, pixels[*datap++]);
  838.     }
  839.       }
  840.       break;
  841.     case ITER_WORD|DISP_generic:
  842.       /* Slow but portable drawing of 16-bit values on 8-plane displays */
  843.       { unsigned short *datap = (unsigned short *) data;
  844.     for(j=0; j<height; j++)
  845.     { for(i=0; i<width; i++)
  846.         XPutPixel(w->ms.rectbuffer, i, j, pixels[*datap++]);
  847.     }
  848.       }
  849.       break;
  850.     default:
  851.       XtAppError(thisApp, "no drawing routine defined for this display type");
  852.     }
  853.  
  854.     if(w->ms.sony_bug_workaround)
  855.     { /* ugly workaround for a bug causing some Sony X servers to */
  856.       /* crash in greyscale mode */
  857.       height=32;
  858.       width=32;
  859.     }
  860.  
  861.     /* go do it! */
  862.     XPutImage(XtDisplay(w), XtWindow(w), DefaultGCOfScreen(XtScreen(w)),
  863.           w->ms.rectbuffer, 
  864.           0, 0, /* position in the buffer */
  865.           x, y, /* position on the screen */
  866.           width, height);
  867.   }
  868.   w->ms.xi.chunks_out--; /* one less to go */
  869.  
  870.   if(w->ms.xi.chunks_out==0)
  871.     UnhideBox(w);
  872. }
  873.  
  874.  
  875. /* Destroy this window (only) */
  876.  
  877. static void
  878. CloseAction(w, event, params, nparams)
  879.      MsWidget w;
  880.      XEvent *event;
  881.      String *params;
  882.      Cardinal *nparams;
  883. { XtDestroyWidget(XtParent(w)); /* destroy the shell widget */
  884. }
  885.  
  886.  
  887. /* Ask Mama to shut down */
  888.  
  889. static void 
  890. QuitAction(w, event, params, nparams)
  891.      MsWidget w;
  892.      XEvent *event;
  893.      String *params;
  894.      Cardinal *nparams;
  895. { Shutdown(w->ms.mama);
  896. }
  897.